# -*- coding: utf-8 -*-
# -数据结构：列表的使用-
# @Time    : 2019/7/8 16:41
# @Author  : hwx
# @Email   : @163.com
# @File    : 官方教程5_6.py
# @Software: PyCharm


def fun6():
    listDemo1 = ['orange', 'banana', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
    print(listDemo1.count('apple'))
    print(listDemo1.count('sdfa'))
    print(listDemo1.index('apple'))
    print(listDemo1.index('banana'))
    print(listDemo1.index('banana', 5))
    listDemo1.append('oppo')
    listDemo1.sort()  # 排序
    print(listDemo1)
    print(listDemo1.pop())  # 删除列表中给定位置的元素并返回它。如果没有给定位置，a.pop() 将会删除并返回列表中的最后一个
                            # 元素。
    listDemo1.reverse()  # 列表反转
    print(listDemo1)
    #   列表作为栈使用 最后一个插入，最先取出（“后进先出”）。要添加一个元素到堆栈的顶端，使用 append() 。
    #   要从堆栈顶部取出一个元素，使用 pop() ，不用指定索引
    print('————————————————栈的使用——————————————————————')
    stackList = [1, 2, 3, 8, 9, 55, 66]
    stackList.append(100)
    print(stackList.pop())
    print(stackList.pop())
    print(stackList)
    print('_____________________________________________________')


# fun6()


#   列表推导式列表推导式提供了一个更简单的创建列表的方法。常见的用法是把某种操作应用于序列或可迭代对象的每个元素上，
#   然后使用其结果来创建列表，或者通过满足某些特定条件元素来创建子序列
def fun1():
    listDemo2 = []
    for x in range(10):
        listDemo2.append(x**2)
    print(listDemo2)


#   列表推导式的结构是由一对方括号所包含的以下内容：一个表达式，后面跟一个 for 子句，然后是零个或多个 for 或 if 子句。
#   其结果将是一个新列表，由对表达式依据后面的 for 和 if 子句的内容进行求值计算而得出
def fun2():
    listDemo3 = []
    for x2 in range(10):
        # listDemo3 = list(map(lambda x2: x2**3, range(10)))
        listDemo3 = [x**2 for x in range(10)]
    print(listDemo3)


print("------------------------------------------------------")


def fun3():
    vec = [-4, -3, -8, 0, 2, 4, 5]
    listDemo4 = [x ** 2 for x in vec]
    print(listDemo4)
    listDemo5 = [x for x in vec if x >= 0]
    combs = [(x, y) for x in [1, 2, 3] for y in [2, 3, 4, 9] if x != y]
    combs2 = [(x, y) for x in [1, 2, 3] for y in [2, 3, 4, 9] if x == y]
    print(combs)
    print(combs2)


# fun3()
#   内置函数zip()
print('——————————内置函数zip——————————————————————————')


def fun4():
    x = [1, 2, 3]
    y = [4, 5, 6, 7]
    zipped = zip(x, y)  # 以维度较小的为长度
    print(list(zipped))


# fun4()


def fun5():
    listDemo6 = [-1, 1, 66.25, 333, 333, 1234.5]
    del listDemo6[0]
    del listDemo6[2:]
    print(listDemo6)
    del listDemo6  # 删除变量，此后再引用 listDemo6 时会报错


#   del语句：del 语句也可以用来从列表中移除切片或者清空整个列表
# fun5()
def fun7():
    """
    一个元组由几个被逗号隔开的值组成,
    元组在输出时总是被圆括号包围的，以便正确表示嵌套元组。输入时圆括号可有可无，不过经常会是必须的（如果这个元组是
    一个更大的表达式的一部分）。给元组中的一个单独的元素赋值是不允许的，当然你可以创建包含可变对象的元组，例如列表。
虽然元组可能看起来与列表很像，但它们通常是在不同的场景被使用，并且有着不同的用途。元组是 immutable （不可变的），
其序列通常包含不同种类的元素，并且通过解包（这一节下面会解释）或者索引来访问
（如果是 namedtuples 的话甚至还可以通过属性访问）。列表是 mutable （可变的），并且列表中的元素一般是同种类型的，
并且通过迭代访问。
    """
    t = 1, 22, 345, 'hello'
    print(t, '\n', t[1])
    u = t, (1, 2, 5)
    print(u)
    # t[2] = 99   # 不可变得，所以会出错
    v = ([1, 2, 3], [3, 2, 1])
    print(v)
    # 构造空元组合氮元素元组
    empty = ()
    singleton = 3,  # 含有一个元素的元组可以通过在这个元素后添加一个逗号来构建
    print(len(empty))
    print(len(singleton))


# fun7()
def fun8():
    """
集合：集合是由不重复元素组成的无序的集。它的基本用法包括成员检测和消除重复元素。集合对象也支持像 联合，交集，差集，
对称差分等数学运算。花括号或 set() 函数可以用来创建集合。注意：要创建一个空集合你只能用 set() 而不能用 {}，
因为后者是创建一个空字典，
    """
    emptyset = set()
    setdemo = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}  # 显示重复项已被删除
    print(emptyset, '\n', setdemo, '\n', 'pear' in setdemo, '2' in setdemo)
    setdemo2 = set('absdfwrgad')
    setdemo3 = set('absyuyigjwa')
    print(setdemo2, '\n', setdemo3)     # 集合没有顺序
    # 集合运算
    print(setdemo2 - setdemo3)  # 在2不在3
    print(setdemo2 | setdemo3)  # 在2或在3或同时在2和3
    print(setdemo2 & setdemo3)  # 在2也在3
    print(setdemo2 ^ setdemo3)  # 在2或在3，但没在2和3
    # 集合也支持推导式
    setdemo4 = {x for x in 'abracadabra' if x not in 'abc'}
    print(setdemo4)


# fun8()


def fun9():
    """
字典：字典在其他语言里可能会被叫做 联合内存 或 联合数组。与以连续整数为索引的序列不同，字典是以 关键字 为索引的，
关键字可以是任意不可变类型，通常是字符串或数字。理解字典的最好方式，就是将它看做是一个 键: 值 对的集合，键必须是唯一的
（在一个字典中）。一对花括号可以创建一个空字典：{} 。另一种初始化字典的方式是在一对花括号里放置一些以逗号分隔的键值对，
而这也是字典输出的方式。对一个字典执行 list(d) 将返回包含该字典中所有键的列表，按插入次序排列 (如需其他排序，
则要使用 sorted(d))。要检查字典中是否存在一个特定键，可使用 in 关键字
    """
    dicdemo1 = {}
    dicdemo2 = {'name': 'Jon', 'age': 11}
    print(dicdemo1, '\n', dicdemo2, '\n', dicdemo2['name'])
    dicdemo2['add'] = '仙游'
    print(dicdemo2)
    del dicdemo2['age']
    print(dicdemo2)
    print(list(dicdemo2))       # 列出键
    print(sorted(dicdemo2), '\n', 'add' in dicdemo2, 'aaaa' in dicdemo2)
    dicdemo3 = dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
    print(dicdemo3)


# fun9()


def fun10():
    """
1.当在字典中循环时，用 items() 方法可将关键字和对应的值同时取出
2.当在序列中循环时，用 enumerate() 函数可以将索引位置和其对应的值同时取出
3.当同时在两个或更多序列中循环时，可以用 zip() 函数将其内元素一一匹配。
4.当逆向循环一个序列时，先正向定位序列，然后调用 reversed() 函数
5.如果要按某个指定顺序循环一个序列，可以用 sorted() 函数，它可以在不改动原序列的基础上返回一个新的排好序的序列
    """
    dicdemo1 = {'姓名': 'ii', '年龄': 3, '地址': '仙游', '专业': '计算机'}
    for k, v in dicdemo1.items():
        print(k, ':', v)
    # 2
    listdemo1 = [7, 8, 3, 2, 5, 341]
    for i, v in enumerate(listdemo1):
        print(i, ":", v)
    # 3
    listdemo2 = ['姓名', '年龄', '地址', '专业']
    listdemo3 = ['jon', '12', '仙游', '计算机', '老师', '学生', 'Python']
    for q, a in zip(listdemo2,listdemo3):
        print('你的{0}是什么？是{1}'.format(q, a))
    # 4
    for i in reversed(range(1, 10, 2)):
        print(i)
    # 5
    basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
    for f in sorted(set(basket)):
        print(f)


# fun10()


def fun11():
    """
   1. 比较操作符 in 和 not in 校验一个值是否在（或不在）一个序列里。操作符 is 和 is not 比较两个对象是不是同一个对象，
    这只跟像列表这样的可变对象有关。所有的比较操作符都有相同的优先级，且这个优先级比数值运算符低。
    比较操作可以传递。例如 a < b == c 会校验是否 a 小于 b 并且 b 等于 c。
2.序列对象可以与相同类型的其他对象比较。它们使用 字典顺序 进行比较：首先比较两个序列的第一个元素，如果不同，那么这就决定
了比较操作的结果。如果它们相同，就再比较每个序列的第二个元素，以此类推，直到有一个序列被耗尽。
如果要比较的两个元素本身就是相同类型的序列，那么就递归进行字典顺序比较。如果两个序列中所有的元素都相等，
那么我们认为这两个序列相等。如果一个序列是另一个序列的初始子序列，那么短序列就小于另一个。字典顺序对字符串来说，
是使用单字符的 Unicode 码的顺序。下面是同类型序列之间比较的例子
(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

    """











